SIL: Simple Instruction Language

Instructions: (** = May invoke an exception, ?=optional argument)
	LNR	[REGISTER_ALIAS,?B] (**) (id=1) (Load Nearest Register)
		Loads (or allocates) a register using the current type to a assigned register name.
		Accepted values:
			- VALID ASCII NAME
			- #... (Register Number)
		(B = Type, must be in format of short)
	LRG [A,?B] (id=2) (Load Register Generic (Number))
		Loads (or allocates) a register using the current type to a valid argument.
		Accepted arguments:
			- #... (Register Number)
		(B = Type, must be in format of short)
	MOV [A,B] (**) (id=3) (Move Register Value)
		Moves a register value from register A to register B.
		Register A is then set to the default value.
		
		Accepted arguments:
			- #... (Register Number)
			- VALID REGISTER ALIAS
	CPY [A,B] (**) (id=4) (Copy Register Value)
		Copies a register value from register A to register B.
				
		Accepted arguments:
			- #... (Register Number)
			- VALID REGISTER ALIAS
	WTR [A,B] (id=5) (Write Value To Register)
		Writes a value to a register.
		
		Accepted arguments:
			A:
				- #... (Register Number)
				- VALID REGISTER ALIAS
			B:
				- Valid value for register type (short, int...)
	
	ADD [A,B] (id=6) (Add on Register Values)
		Adds values together.
		If A and B is type REGISTER:
			Equivalent to a += b (or below, since they are the same thing)
		If B is type VALUE:
			Equivalent to a = a + b
		
		Accepted arguments:
			If A and B is type REGISTER:
				- #... (Register Number)
				- VALID REGISTER ALIAS
			If B is type VALUE:
				- #... (Register Number)
				- VALID REGISTER ALIAS
				AND
				- Valid value for register type (short, int...)
	SUB [A,B] (id=7) (Subtract on Register Values)
		See ADD but equivalent to a = a - b
	MUL [A,B] (id=8) (Multiply on Register Values)
		See ADD but equivalent to a = a * b
	DIV [A,B] (**) (id=9) (Divide on Register Values)
		See ADD but equivalent to a = a / b
	MOD [A,B] (id=10) (Modulus on Register Values)
		See ADD but equivalent to a = a % b
	AND [A,B,?C] (id=11) (Perform AND on Register Values)
		If C is present:
			Equivalent to C = A AND B
		Else:
			Equivalent to A = A AND B
			
		Accepted arguments:
			If A and B is type REGISTER:
				- #... (Register Number)
				- VALID REGISTER ALIAS
			If B is type VALUE:
				- #... (Register Number)
				- VALID REGISTER ALIAS
				AND
				- Valid value for register type (short, int...)
			C must be type REGISTER.
	NAND [A,B,?C] (id=12) (Perform NAND on Register Values)
		Performs opposite of AND, see AND for more info.
	OR [A,B,?C] (id=13) (Perform OR on Register Values)
		See AND but equivalent to C = A OR B | A = A OR B
	XOR [A,B,?C] (id=14) (Perform XOR on Register Values)
		See AND but equivalent to C = A ^ B | A = A ^ B
	NOT [A,B?] (id=15) (Perform NOT on Register Values)
		If only A is present:
			Equivalent to A = NOT A
		If A and B is present:
			Equivalent to A = NOT B
			
		Accepted arguments:
			If A and B is type REGISTER:
				- #... (Register Number)
				- VALID REGISTER ALIAS
			If B is type VALUE:
				- #... (Register Number)
				- VALID REGISTER ALIAS
				AND
				- Valid value for register type (short, int...)
	EINT [A] (**) (id=16) (Exception on TRUE INT)
		Throws an exception if A is not TRUE. (0x1)
		
		Accepted arguments:
			- #... (Register Number)
			- VALID REGISTER ALIAS
			- Valid value for register type (short, int...)
	HINT [A] (**) (id=17) (Halt on TRUE INT)
		See EINT, does not throw an exception, however halts execution instead.
	LBL [A,B] (id=18) (Code Label)
		Label containing a set of instructions or more labels.
		
		Arguments:
			A = VALID Label Name (must be ASCII)
			B = Array/List of Instructions
	JMP [A] (**) (id=19) (Jump to Label)
		Jumps to label and invokes the label.
		
		Arguments:
			A = VALID Label Name (must be ASCII)
	JINT [A,B] (**) (id=20) (Jump to Label IF NOT TRUE)
		Jumps to label if register is NOT TRUE.
		
		Arguments:
			A = VALID Label Name (must be ASCII)
			B = Register Number or Alias
	CUPID [A,B] (id=21) (CUP VEE Query by ID)
		Queries various features about the VEE.
		
		Equivelent to B = cupid_query(A)
		Arguments:
			A = SHORT
			B = Valid register alias or number.
		
		Accepted Short Values:
			Number and Name			  Return Type
			00  = NULL					SHORT
			01  = VEE VENDOR			STRING
			02  = VEE NAME				STRING
			03  = VEE MODEL				STRING
			04  = VEE VERSION			SHORT
			05  = NSL SUPPORTED			SHORT (BOOLEAN)
			06  = STI SUPPORTED			SHORT (BOOLEAN)
			07  = NMI SUPPORTED			SHORT (BOOLEAN)
			08  = ESI SUPPORTED			SHORT (BOOLEAN)
			09  = SII SUPPORTED			SHORT (BOOLEAN)
			10  = SIE SUPPORTED			SHORT (BOOLEAN)
			11  = FVO SUPPORTED			SHORT (BOOLEAN)
			/* 12 -> 96: Reserved for future use. */
			97  = IS NATIVE FLAG		SHORT (BOOLEAN)
			98  = SYS ARCH FLAG			SHORT
				1 = x86
				2 = x86_64
				3 = armv6
				4 = armv7
				5 = armv8
				6 = armhf
				7 = riscv
				/* 8 and onwards is reserved for future use. */
				100 = UNKNOWN
			99  = SYS CORE COUNT		SHORT
				Returns 0 IF NATIVE PLATFORM.
			100 = TOTAL MEMORY AMOUNT KB	LONG
				Returns in KB.
			101 = TOTAL USABLE MEMORY AMOUNT KB   LONG
				Returns in KB.
			102 = TOTAL MEMORY AMOUNT BYTES	LONG
				Returns in B.
			103 = TOTAL USABLE MEMORY AMOUNT BYTES   LONG
				Returns in B.
			/* 101 and onwards is reserved for future use. */
	REGTF [A,B] (id=22) (Register Type Of)
		Queries the type of register and returns the value into a SHORT register.
		
		Arguments:
			A = ANY VALID Register
			B = ANY SHORT Register
	HLT			(id=23) (Halt Execution)
		Stops all execution and instruction interpretation.
	NUKE [A] (id=24) (Remove and [Nuke] Register)
		Removes the register from the runtime's register manager.
		
		Arguments:
			A = ANY VALID REGISTER
	INC [A,B] (id=25)
		Increments a valid numerical register by 1 IF B is not provided,
		else will be incremented by B.
		
		Arguments:
			A = ANY NUMERICAL REGISTER
			B = ANY VALID NUMBER (optional)
	DEC [A,B] (id=26)
		Decrements a valid numerical register by 1 IF B is not provided,
		else will be decremented by B.
		
		Arguments:
			A = ANY NUMERICAL REGISTER
			B = ANY VALID NUMBER (optional)
	PFCH [A] (id=27)
		Prefetches the next instruction ID from the decoder, else returns NULL/NOP if there are no more instructions.
		
		Arguments:
			A = ANY NUMERICAL REGISTER
	LNTR [A] (**) (id=28) (Load Nearest Temporary Register)
		Loads a new temporary register which will only exist and function within a local scope. (function)
		
		See LNR (Load Nearest Register) for more information.
		NOTE: All temporary registers will have their identifier be prefixed with a "t$", meaning that:
			>	LNTR 1
			Would need to be interfaced by using "t$1", like so:
			> 	INC "t$1"
		!! This rule does not apply to the MMOI instruction, meaning that "M$" is also a valid prefix and can be provided in LNTR to force usage.
		Accepted values:
			- VALID ASCII NAME
			- #... (Register Number)
	/* TODO: Add array registers and operations on arrays */
		